#!/usr/bin/env python3
# Created by han on 2016/6/6
import time,os,sys,platform,random
if platform.system() == 'Windows':
    BASE_DIR = '\\'.join(os.path.dirname(__file__).split('/')[:-1])
else:
    BASE_DIR = '/'.join(os.path.dirname(__file__).split('/')[:-1])
sys.path.append(BASE_DIR)

from module import public
from conf import db_conf
from module import accout


DB_USER = os.listdir(db_conf.DB_BASE)

LOCAL_STRUCT = time.localtime()
LOCAL_TIME = "{year}-{month}-{day}".format(year=LOCAL_STRUCT.tm_year, month=LOCAL_STRUCT.tm_mon, day=LOCAL_STRUCT.tm_mday)
if LOCAL_STRUCT.tm_mday > 22:
    LOCAL_UNSET_TIME = "{year}-{month}-22".format(year=LOCAL_STRUCT.tm_year, month=LOCAL_STRUCT.tm_mon+1)
else:
    LOCAL_UNSET_TIME = "{year}-{month}-22".format(year=LOCAL_STRUCT.tm_year, month=LOCAL_STRUCT.tm_mon)

#print(LOCAL_UNSET_TIME)
if LOCAL_STRUCT.tm_mday <= 22:
    OUT_TIME = "{year}-{month}-11".format(year=LOCAL_STRUCT.tm_year, month=LOCAL_STRUCT.tm_mon+1)
else:
    OUT_TIME = "{year}-{month}-11".format(year=LOCAL_STRUCT.tm_year, month=LOCAL_STRUCT.tm_mon +2)


def manage_outer(func):
    def inner():
        user_name = input("请输入管理员账号： ")
        user_pass = input("请输入管理员密码： ")
        root_file = public.load_file("root")
        if user_name == root_file["user"] and user_pass == root_file["passwd"]:
            return func()
        else:
            print("您没有权限，请您重新选择")
            return False
    return inner


@manage_outer
def manage():
    while True:
        manage_menu = ["开卡","注销","修改"]
        user_chose = public.user_chose(*manage_menu)
        if user_chose:
            if user_chose == "1":
                user_dict = open_card()
            elif user_chose == "2":
                close_user = change_info()
                close_account(close_user)
            elif user_chose == "3":
                modifiy_user = change_info()
                if not modifiy_user:
                    continue
                manage_change(modifiy_user)

            elif user_chose == "0":
                msg = " goodbye ".center(35, "=")
                public.color_msg(39, msg)
                break


def change_info():
    """
        "获取银行账户所有用户的账户名，并让用户进行选择把选择结果返回"
    :return: 返回用户的选择
    """
    while True:
        global  DB_USER
        DB_USER = os.listdir(db_conf.DB_BASE)
        user_list = []
        for user_name in DB_USER:
            if user_name != "root" and user_name != "__init__.py":
                user_list.append(user_name)
        for i in enumerate(user_list):
            name = i[1].split(",")
            print(i[0]+1,",",name[0],name[1])
        user_chose = input("请您选择要修改的用户： ")
        if user_chose == "b":
            return False
        if user_chose.isdigit() and int(user_chose) <= len(user_list):
            user_name = user_list[int(user_chose)-1]
            return user_name
        else:
            msg = "输入有误请重新选择： ".center(40," ")
            public.color_msg(32,msg)


def manage_change(user_file):
    while True:
        change_menu = ["ret_passwd","lock_account","unlock_account"]
        for menu in enumerate(change_menu):
            print(menu[0]+1,menu[1])
        user_chose = input("请输入您需要操作对应的-文字-或按【b】退出(反射知识点)： ")
        if user_chose == "b":
            break
        if hasattr(accout,user_chose):                      #反射，检查是否在accout中是否有用户输入的函数
            func = getattr(accout, user_chose)              #如果有则获取这个函数
            func(user_file)                                 #执行这个函数
        else:
            msg = "输入有误请您重新输入： "
            public.color_msg(31, msg)
            continue


def ret_passwd(user_file):
    """
    密码重置
    :param user_file:接收 manage_change 返回值 用户信息文件名称
    :return: 重置密码成功并返回新的用户信息dict
    """
    while True:
        user_dict = public.load_file(user_file)
        user_dict["passwd"] = "123"
        user_sure = input("确认恢复密码为123请按【y】,【n】取消")
        if user_sure == "y":
            new_user_list = ret_info(user_file,**user_dict)
            msg = "密码重置完毕，".center(40," ")
            public.bank_log.warning("%s用户密码重置"%user_dict["user"])
            public.color_msg(32,msg)
            return new_user_list
        elif user_sure == "n":
            break
        else:
            msg = "输入有误请重新输入： ".center(40," ")
            public.color_msg(31,msg)
            continue


def lock_account(file_name):
    while True:
        user_id, name = file_name.split(",")
        user_chose = input("是否要锁定%s账户 [y/n]"% name)
        if user_chose == "y":
            user_dict = public.load_file(file_name)
            user_dict["lock"] = 3
            ret_info(file_name,**user_dict)
            msg = "%s 锁定成功"%name
            public.bank_log.warning("%s账户锁定"%user_dict["user"])
            public.color_msg(32, msg)
            return True
        else:
            break


def unlock_account(file_name):
    while True:
        user_id, name = file_name.split(",")
        user_chose = input("是否要解锁%s账户 [y/n]"% name)
        if user_chose == "y":
            user_dict = public.load_file(file_name)
            user_dict["lock"] = 0
            ret_info(file_name,**user_dict)
            public.bank_log.warning("%s账户解锁" % user_dict["user"])
            msg = "%s 解锁成功"%name
            public.color_msg(32, msg)
            return True
        else:
            break


def close_account(file_name):
    while True:
        user_id, name = file_name.split(",")
        user_chose = input("是否要注销%s账户 [y/n]"% name)
        if user_chose == "y":
            local_file = db_conf.DB_BASE + '/' + file_name
            os.remove(local_file)
            public.bank_log.warning("%s销户" % file_name)
            msg = "%s 账户注销成功"%name
            public.color_msg(32, msg)
            return True
        else:
            break


def new_login_info():
    """
    登录接口，提供用户输入用户名密码，并检测
    #:return: 用户的信息字典
    :return: 用户的文件名称
    """
    while True:
        user_name = input("登录用户名或者 card_id 【b】退出： ")                              #用户可能输入用户名或者id
        user_info = public.user_info()
        if user_name in user_info[0] or user_name in user_info[1]:                    #判断用户名在db文件中 如果用户输入是id或者是name
            user_passwd = input("请输入登录密码： ")
            if user_name in user_info[0]:                   #如果用户在id中
                file_name = public.start_find_file(user_name)
            else:                                           #如果用户在name中
                file_name = public.end_find_file(user_name)
            user_dict = public.load_file(file_name)         #通过load_file取出用户的字典信息,所以日期信息与全局变量没有关系了。
            if user_dict["lock"] == 3:
                public.bank_log.warning("%s锁定用户尝试多次登录"%user_name)
                msg = "您的账户已经被锁定，请联系银行人员处理".center(40," ")
                public.color_msg(31,msg)
                break
            if user_dict["passwd"] == user_passwd:       #判断用户的用户名密码
                user_dict["lock"] = 0
                new_user_dict = ret_info(file_name, **user_dict)                        #计算用户信用卡中的钱并存入文件
                public.bank_log.info("%s 用户登录"%user_name)
                return file_name,new_user_dict                                        #正确返回用户信息字典
            else:
                user_dict["lock"] = user_dict["lock"]+1
                public.save_file(file_name,**user_dict)
                public.bank_log.warning("%s用户密码输入错误，错误次数%d"%(user_name,user_dict["lock"]))
                msg = "--用户名或密码有误，请重新输入--".center(40," ")
                public.color_msg(31,msg)
        elif user_name == "b":
            return False
        else:
            msg = "用户名或密码有误，请重新输入".center(40, " ")
            public.color_msg(31, msg)


def ret_info(file_name, **user_dict):
    """
    user_info = {"user": "", "passwd": "123", "lock": 0,
                 "money": {"money": 0, "avaliable": 15000, "unsettled": [LOCAL_TIME, 100], "out": [2016-7-11, 0],
                           "interest": 2+2+4, "return": 0, "interest_raw": 100}}
                           "interest": 0, "return": 0, "interest_raw":0}

    :param user_dict:获取用户信息字典
    :return:对当前用户金额进行计算后返回出最终金额的用户信息字典
    """
    old_unset_time = user_dict["money"]["unsettled"][0]
    user_dict["money"]["unsettled"][0] = LOCAL_TIME         #由于user_dict是从文件中取出的，所以此数值已经固定，不会根据时间变化而变化了。
    new_unset_time = user_dict["money"]["unsettled"][0]     #固需要重新将动态的环境变量中的时间字符串重新赋值给这里面的localtime好用于整个程序的计时标准
    out_time = user_dict["money"]["out"][0]
    #先将时间参数  -  改变
    if new_unset_time == out_time:                              #到了10号 如果未出账单钱的时间等于了还款日时间，就要将还款日时间往下个月加一个月
        user_dict["money"]["out"][0] = public.next_month(11)    #将还款日时间重新用自定义的函数定义
        user_dict["money"]["interest_raw"] += user_dict["money"]["out"][1]               #总逾期未还金额为新原未还金额+新产生的费用
        user_dict["money"]["out"][1] = 0
    if new_unset_time == LOCAL_UNSET_TIME:                                     #如果动态的新时间等于每个月的22日,如果时间到了每月的账单日
        user_dict["money"]["out"][1] += user_dict["money"]["unsettled"][1]      #就要把未出账单的钱重新付给 out 已出账单里
        user_dict["money"]["unsettled"][1] = 0                                  #如果要是22日当天消费的钱，就会被反复的放到已出账单中，哪就这么放吧。
    if old_unset_time < new_unset_time:                                         #在刚提取用户信息时，如果不在一天，才计算利息。是一天则保持原有利息。
        days = public.daysdiff(old_unset_time,new_unset_time)
        user_dict["money"]["interest"] += user_dict["money"]["interest_raw"] * 0.0005 * days      #利息这个数值等于 = 利息本身 + interest_raw * 0.0005 *出息后又相差的天数
    if user_dict["money"]["interest_raw"] != 0:                                                         #如果利息这里有数值，代表interest_raw里面也有数值，此时需要判断用户是否还钱。
        if user_dict["money"]["return"] >= user_dict["money"]["interest_raw"] + user_dict["money"]["interest"]: #如果还账的钱数大于或等于所欠金额和利息的总和
            new_return = user_dict["money"]["return"] - user_dict["money"]["interest"]             #需要放回信用账户的钱等于 所还的钱 减去利息的钱
            user_dict["money"]["avaliable"] += new_return                           #将钱款归还到账户中
            user_dict["money"]["interest"] = 0                                      #清零利息
            user_dict["money"]["interest_raw"] = 0                                  #清零钱款
            user_dict["money"]["return"]= 0                                         #清零还钱账户
    public.save_file(file_name, **user_dict)
    return user_dict


def before(arg,filename):
    """
    用户对钱进行操作时的先做的一个展示操作。
    :param arg: 输出的操作内容
    :param filename:用户的文件名
    :return: 返回用户要操作的金额数字
    """
    while True:
        raw_user_dict = public.load_file(filename)                 #读取用户原始信息
        new_user_dict = ret_info(filename,**raw_user_dict)                   #为了展示需要处理一下数据，以便获得处理完金额的数据
        public.user_format(**new_user_dict)                         #格式化显示出当前时间
        msg = "当前日期：%s\n"%LOCAL_TIME.center(40,"-")
        public.color_msg(32,msg)
        user_inp = input("请输入您要%s的金额或按【b】退出： "%arg)
        if user_inp and user_inp.isdigit():
            user_inp = int(user_inp)
            return user_inp
        elif user_inp == "b":
            return False
        else:
            msg = "输入有误请重新输入".center(40," ")
            public.color_msg(31,msg)
            continue


def out_money(arg,filename):
    """
    信用卡提现
    :param arg:接收用户需要提现的金额
    :param login_info: 该用户的文件名
    :return:
    """
    user_dict = public.load_file(filename)             #找出这个用户的字典
    ret_info(filename,**user_dict)                                 #将用户这个字典进行计算并再放回文件中
    new_user_dict = public.load_file(filename)         #此时拿到的就是最新状态的用户信息
    cost = arg * 0.05                                   #计算出利息
    unset = arg + cost                                  #账户金额应该变动的钱数
    if new_user_dict["money"]["avaliable"] >= unset:
        new_user_dict["money"]["avaliable"] -= unset        #用户总金额按照借钱+利息扣钱，
        new_user_dict["money"]["unsettled"][1] += unset     #将借出的钱加利息算到未出账单中
        new_user_dict["money"]["money"] += arg              #将提现的金额放到用户的现金账户中
        user_sure = input("是否确认提取：【y】确认,【n】退出")
        if user_sure == "y":
            public.save_file(filename,**new_user_dict)         #将新用户字典信息存放到文件中
            msg = "提取现金成功，请查看账户确认".center(40," ")
            public.color_msg(32,msg)
            return True
        else:
            msg = "取消操作，返回上层".center(40," ")
            public.color_msg(31,msg)
            return False
    else:
        msg = "信用账号余额不足，无法提现".center(40," ")
        public.color_msg(31,msg)
        return False


def transfer_judge(filename):
    """
    :param filename:接受转账用户的文件名
    接收用户的转账输入账号，确认是否存在
    :return: 确定有的话就返回要转账对象的文件名
    """
    while True:
        tran_user = input("请您输入您要转账的用户名或【b】退出： ")
        if tran_user == "b":
            msg = "退出".center(40,"=")
            public.color_msg(39,msg)
            return False
        if tran_user.isalnum():
            id, name = filename.split(",")
            all_id, all_name = public.user_info()
            if tran_user in all_name and tran_user != name:
                msg = "您要转账的用户为{name:*^10s}".format(name=tran_user).center(40," ")
                public.color_msg(33,msg)
                user_chose = input("是否确认转账用户：【y】确定，其他键返回： ")
                if user_chose == "y":
                    for i in DB_USER:
                        if i != "root" and i != "__init.py":
                            id, name = i.split(",")
                            if name == tran_user:
                                print(filename,i,"000000000000")
                                return filename, i, tran_user

                else:
                    continue
            else:
                msg = "没有这个用户或转账用户不符，请您重新输入".center(40," ")
                public.color_msg(31,msg)
                continue
        else:
            msg = "您输入有误请重新输入"
            public.color_msg(31,msg)
            continue


def transfer(filename,out_to_file,in_name):
    """
    获取用户转账对象与转出用户，并转账
    :param filename: 转出账户名称
    :param out_to_file: 转入账户名称
    :return: 转账成功为真，取消为假
    """
    while True:
        out_user_dict = public.load_file(filename)                      #将此用户的信息从文件中读出
        new_out_user_dict = ret_info(filename,**out_user_dict)                   #计算利息后放入文件
        to_user_dict = public.load_file(out_to_file)                            #获取转出用户信息
        new_to_user_dict = ret_info(out_to_file,**to_user_dict)                     #计算利息后放入文件
        out_user_money = input("请输入您要转账的金额或【b】退出： ")        #要转的金额
        if out_user_money == "b":                                       #退出
            return False
        if out_user_money.isdigit():                                    #如果输入的是数字
            out_user_money = int(out_user_money)
            if out_user_money > new_out_user_dict["money"]["money"]:        #判断转出金额如果大于用户账户的可用余额
                msg = "您的可用余额不足，请您查看用户账户信息".center(40," ")
                public.color_msg(31,msg)
                continue
            new_out_user_dict["money"]["money"] -= out_user_money           #不大于就做账户的扣款
            new_to_user_dict["money"]["money"] += out_user_money            #对方账户的增加
            msg = "您要转账的用户为{name:*^10s}，金额为{money:*^10d}".format(name=in_name,money=out_user_money).center(50," ")
            public.color_msg(33,msg)                                            #展示转账的内容
            user_chose = input("是否确认转账用户：【y】确定，其他键返回")
            if user_chose != "y":                                               #如果不是y则返回重新输入转账金额
                continue
            else:
                ret_info(out_to_file,**new_to_user_dict)                                    #如果确认就对操作后的存款账户做计算并保存
                out_after_dict = ret_info(filename,**new_out_user_dict)                  #再对转出账户的状态做保存
                msg = "转账成功，账户信息为".center(40," ")
                public.color_msg(31,msg)
                public.user_format(**out_after_dict)                             #显示转账后账户信息
                return True


def back_money(arg, filename):
    """
        :param arg: 用户还款金额
        :param filename:获取用户文件名称
        :return:还款成功返回真
        """
    while True:
        user_dict = public.load_file(filename)
        if user_dict["money"]["interest_raw"] == 0:                 #当没有逾期时
            if user_dict["money"]["out"][1] == 0:                   # 如果没有已出账单。证明不用还钱
                msg = "你的金额已还清，本月不需要还款".center(40," ")
                public.color_msg(33,msg)
                return "1"
            if arg <= user_dict["money"]["out"][1]:                 #如果还款金额小于或者等于已出账单金额
                user_dict["money"]["out"][1] -= arg                 #已出账单等于 自身金额 - 还款金额
                user_dict["money"]["avaliable"] += arg              #可用额度等于自身 +  还款金额
                public.bank_log.info("还款成功")
                msg = "您本次还款金额为{money:*^10d}".format(money=arg).center(40," ")
                public.color_msg(32,msg)
                public.ensure_save(filename,**user_dict)                     #调取确认还款函数
                public.bank_log.info("%s 还款成功"%user_dict["user"])
                return True
            if arg > user_dict["money"]["out"][1]:                  #如果还款金额大于已出账单
                user_dict["money"]["avaliable"] += arg              #可用额度等于 自身金额 + 所还款金额，余额肯定会超过初始金额
                user_dict["money"]["out"][1] = 0                    #清空已出账单
                msg = "您本次还款金额为{money:*^10d}".format(money=arg).center(40, " ")
                public.color_msg(32, msg)
                public.ensure_save(filename, **user_dict)
                public.bank_log.info("%s 还款成功" % user_dict["user"])
                return True
        else:                                                                                       #如果有逾期
            if user_dict["money"]["return"] == 0:                                                       #没有发生逾期后没还够的情况
                if arg >= user_dict["money"]["interest"] + user_dict["money"]["interest_raw"]:          #此时还款金额大于 产生的利息 + 逾期未还金额
                    # if user_dict["money"]["out"] == 0:                                                  #如果此时没有已出账单
                        more = arg - user_dict["money"]["interest"]
                        if more >= user_dict["money"]["interest_raw"]:                                   #已还金额的钱 - 利息的钱如果大于逾期未还的金额
                            if user_dict["money"]["out"][1] == 0:                                                  #如果此时没有已出账单
                                user_dict["money"]["avaliable"] += more                                     #将已还金额扣除利息，增加到可用额度里面
                                user_dict["money"]["interest"] = 0
                                user_dict["money"]["interest_raw"] = 0
                            else:                                                                               #如果此时又有了已出账单
                                if more >= user_dict["money"]["out"][1] + user_dict["money"]["interest_raw"]:   #判断减去利息的钱大于或等于已出账单和于预期账单的总和
                                    user_dict["money"]["out"][1] = 0                                   #将移除清空
                                    user_dict["money"]["avaliable"] += more                         # 将已还金额扣除利息，增加到可用额度里面
                                    user_dict["money"]["interest"] = 0                              #将利息清空
                                    user_dict["money"]["interest_raw"] = 0                          #将逾期清空
                                else:                                                                          #判断减去利息的钱大于逾期的钱但是多出来的钱又小于再出的已出账单的钱
                                    user_dict["money"]["avaliable"] += user_dict["money"]["interest_raw"]      #将等同于逾期的钱放回到信用额度中
                                    add_out = more - user_dict["money"]["interest_raw"]                        #并将减去利息的钱减去逾期的钱放到移除账单中
                                    user_dict["money"]["out"][1] -= add_out
                                    user_dict["money"]["interest_raw"] = 0                         #并将逾期金额清空
                                    user_dict["money"]["interest"] = 0                              #将利息清空
                        else:                                                                       #还款金额的钱 - 利息小于逾期的钱
                            if arg >= user_dict["money"]["interest"]:                               #
                                user_dict["money"]["interest"] = 0
                                user_dict["money"]["return"] += more
                            else:
                                user_dict["money"]["interest"] -= arg
            else:                                                                                   #如果return中有值，证明有过逾期后还钱没有还够的情况
                balance = user_dict["money"]["interest_raw"] - user_dict["money"][
                    "return"]  # 算出还差多少钱就还够了
                if arg < balance:  # 如果已还的金额小于相差的金额
                    more = arg - user_dict["money"]["interest"]  # 算出减去利息的钱
                    user_dict["money"]["interest"] = 0  # 将利息清空
                    user_dict["money"]["return"] += more  # 将剩余的钱+倒return中
                else:  # 如果还款金额大于还差的金额
                    if user_dict["money"]["out"][1] == 0:  # 此时就可以考虑是否已经出了下期的已出账单
                        more = arg - user_dict["money"]["interest"]  # 算出减去利息的钱
                        all_money = more + user_dict["money"]["return"]  # 将本次减去利息的钱与上次换的钱相加
                        user_dict["money"]["interest"] = 0  # 清零利息
                        user_dict["money"]["interest_raw"] = 0  # 清零逾期
                        user_dict["money"]["avaliable"] += all_money  # 将换的钱加回信用额度中
                        user_dict["money"]["return"] = 0  # 清零上回已经还款的金额
                    else:  # 如果出了已出账单了
                        more = arg - user_dict["money"]["interest"]  # 减去利息所换的钱
                        out_balance = more - balance  # 换的钱 - 还差的钱就等于多还的钱
                        if out_balance >= user_dict["money"]["out"][1]:  # 如果多换的钱大于已出账单的钱
                            all_money = more + user_dict["money"]["return"]  # 这次换的钱加上之前换的钱
                            user_dict["money"]["avaliable"] += all_money  # 加会到信用账户中
                            user_dict["money"]["return"] = 0  # 并将所有的还清
                            user_dict["money"]["interest_raw"] = 0
                            user_dict["money"]["interest"] = 0
                            user_dict["money"]["out"][1] = 0
                        else:  # 如果换的钱多出来的部分小于已出账单的钱
                            user_dict["money"]["out"][1] -= out_balance
                            user_dict["money"]["avaliable"] += out_balance
                            user_dict["money"]["avaliable"] += user_dict["money"]["interest_raw"]
                            user_dict["money"]["interest_raw"] = 0
                            user_dict["money"]["interest"] = 0
                            user_dict["money"]["return"] = 0
        public.ensure_save(**user_dict)
        public.bank_log.info("%s 还款成功" % user_dict["user"])
        return True


def open_card():
    """
    初始化用户信息，请管理员输入要注册的用户名及信用卡内金额，初始化密码为123
    :return: 返回用户信息的字典
    """
    while True:
        user_name = input("请输入开户用户名：")
        if user_name and not user_name.isdigit() and len(user_name) > 1:      #用户输入怒能为纯数字，并且长度要大于1位：
            user_list = []
            for file_name in DB_USER:
                if file_name != "root" and file_name != "__init__.py":
                    id,user = file_name.split(",")
                    user_list.append(user)
            if user_name in user_list:                            #如果注册的用户名已经存在，则提示错误
                msg = "这个用户已经存在，请重新输入".center(40," ")
                public.color_msg(31,msg)
                continue
            while True:                                           #对注册时输入金额做判断，不能为空
                user_money = input("请输入信用额度： ")
                if not user_money or not user_money.isdigit():
                    msg = "金额不能为空且必须是数字".center(40," ")
                    public.color_msg(31,msg)
                    continue
                else:
                    user_money = int(user_money)
                    break
            while True:
                b = []
                for i in range(8):                                          #自动生成8位的数字
                    a = random.randrange(1, 9)                              #每个数字在1-9中间挑选
                    b.append(str(a))                                        #将数字转化为str添加进b列表，因为数字列表不能被join
                card_id = "".join(b)                                        #生成卡号
                all_id = []
                for user_str in DB_USER:                                   #循环遍历银行卡数据中的用户文件名称
                    if user_str != "root" and user_str != "__init__.py":  #除去root和__init__.py
                        id,name =  user_str.split(",")                     #将每个用户列表以分号拆分
                        all_id.append(id)                                   #每次都将循环出来的id放进这个list中
                if card_id not in  all_id:                                  #如果新生成的card_id不在这个list中
                    break                                                   #退出
        elif user_name == "b":                              #如果输入b则退出
            msg = " goodbye ".center(35,"=")
            public.color_msg(39,msg)
            break
        else:                                                   #如果输入有误，则提示错误
            msg = "用户名必须是大于【1】位的英文字母且不能为空或【b】退出".center(40," ")
            public.color_msg(31,msg)
            continue

        """
        #初始化用户信息数据，unsttled:未出账单，out:已出账单,avaliable:信用余额，money:现金额度，interest:利息，
        #return:已还金额，interest_raw:计息标准金额
        """
        user_info = {"user": "","card_id":"","passwd": "123","lock":0,"money": {"money": 0, "avaliable": 0, "unsettled": [LOCAL_TIME, 0], "out": [OUT_TIME, 0],
                                                                     "interest": 0, "return": 0, "interest_raw": 0}}

        user_info["user"] = user_name
        user_info["card_id"] = card_id
        user_info["money"]["avaliable"] = user_money
        user_file_name = card_id + "," + user_name
        print(user_file_name,type(user_file_name))
        public.save_file(user_file_name,**user_info)
        msg = "用户{user:*^8s}开卡成功，卡号为：{card_id:+^15s}信用额度为{money:*^11d}，默认登录密码 123\n牢记您用户id，登陆与消费可以使用用户名也可以使用id".format(user=user_name,card_id=card_id,money=user_money).center(45," ")
        public.color_msg(32,msg)
        global DB_USER
        DB_USER = os.listdir(db_conf.DB_BASE)
        public.bank_log.info("%s 开卡成功" % user_name)
        return user_info


def change_passwd(file_name):
    user_dict = public.load_file(file_name)
    old_passwd = user_dict["passwd"]
    while True:
        user_input_old = input("请您输入原密码： ")
        if user_input_old != old_passwd:
            msg = "您输入的原密码有误请重新输入： "
            public.color_msg(31,msg)
            continue
        else:
            break
    while True:
        user_input_new1 = input("请您输入新密码： ")
        user_input_new2 = input("请您在次输入新密码： ")
        if user_input_new1 != user_input_new2:
            msg = "两次密码输入不一样，请您重新输入"
            public.color_msg(31,msg)
            continue
        else:
            user_dict["passwd"] = user_input_new2
            break
    while True:
        user_chose = input("是否保存修改： [y/n]")
        if user_chose == "n":
            break
        elif user_chose == "y":
            new_user_dict = ret_info(file_name,**user_dict)
            public.bank_log.info("%s 密码修改成功" % user_dict["user"])
            return new_user_dict
        else:
            msg = "您输入有误请重新输入"
            public.color_msg(31,msg)
            continue